const fs = require('fs');
const path = require('path');

// 读取生成的 HTML 文件
const htmlPath = path.join(__dirname, 'dist', 'index.html');
const publicHtmlPath = path.join(__dirname, 'dist', 'public', 'index.html');
let html = fs.readFileSync(htmlPath, 'utf8');
let publicHtml = '';

// 检查 public/index.html 是否存在
if (fs.existsSync(publicHtmlPath)) {
  publicHtml = fs.readFileSync(publicHtmlPath, 'utf8');
}

// 处理HTML文件的函数
function processHtml(htmlContent, isPublicHtml = false) {
  let processedHtml = htmlContent;
  
  // 根据文件位置确定正确的相对路径
  const jsPath = isPublicHtml ? '../js/main.js' : './js/main.js';
  
  // 替换模块化的 script 标签为普通的 script 标签
  processedHtml = processedHtml.replace(
    /<script type="module" crossorigin src="\/js\/[^"]*\.js"><\/script>/g,
    `<script src="${jsPath}"></script>`
  );
  
  // 如果上面的替换没有生效，尝试更宽松的匹配
  processedHtml = processedHtml.replace(
    /<script[^>]*src="\/js\/[^"]*\.js"[^>]*><\/script>/g,
    `<script src="${jsPath}"></script>`
  );
  
  // 处理已经存在的相对路径（修复错误的相对路径）
  processedHtml = processedHtml.replace(
    /<script[^>]*src="\.\.?\/js\/[^"]*\.js"[^>]*><\/script>/g,
    `<script src="${jsPath}"></script>`
  );
  
  // 移除所有 modulepreload 链接
  processedHtml = processedHtml.replace(/<link rel="modulepreload"[^>]*>/g, '');
  
  // 移除所有 CSS 链接（因为 CSS 已经内联到 JS 中）
  processedHtml = processedHtml.replace(/<link rel="stylesheet"[^>]*>/g, '');
  
  // 修复路径问题：将绝对路径改为相对路径
  // 移除 manifest.json 引用，避免 CORS 错误
  processedHtml = processedHtml.replace(/<link rel="manifest"[^>]*>/g, '');
  processedHtml = processedHtml.replace(/href="\/favicon\.svg"/g, 'href="./favicon.svg"');
  // 移除 favicon.png 引用，因为文件不存在
  processedHtml = processedHtml.replace(/href="\/favicon\.png"/g, 'href="./favicon.svg"');
  processedHtml = processedHtml.replace(/src="\/favicon\.png"/g, 'src="./favicon.svg"');
  
  return processedHtml;
}

// 处理主HTML文件
html = processHtml(html, false);

// 处理public/index.html文件（如果存在）
if (publicHtml) {
  publicHtml = processHtml(publicHtml, true);
}

// 添加更好的错误处理 - 需要在页面最开始就执行
const errorHandlerScript = `
<script>
// 立即执行的DOM保护，在任何其他脚本之前
(function(){
  // 重写所有可能访问style的方法
  var originalDefineProperty = Object.defineProperty;
  var styleDescriptor = {
    get: function() {
      if (this == null || this === null || this === undefined) {
        console.warn('Blocked null style access');
        return {};
      }
      return this._internalStyle || (this._internalStyle = {});
    },
    set: function(value) {
      if (this == null || this === null || this === undefined) {
        console.warn('Blocked null style assignment');
        return;
      }
      this._internalStyle = value;
    },
    configurable: true,
    enumerable: true
  };
  
  // 在Element原型上设置style保护
  try {
    if (window.Element && Element.prototype) {
      originalDefineProperty.call(Object, Element.prototype, 'style', styleDescriptor);
    }
  } catch(e) { console.warn('Element style protection failed:', e); }
  
  // 在HTMLElement原型上设置style保护
  try {
    if (window.HTMLElement && HTMLElement.prototype) {
      originalDefineProperty.call(Object, HTMLElement.prototype, 'style', styleDescriptor);
    }
  } catch(e) { console.warn('HTMLElement style protection failed:', e); }
  
  // 保护所有可能的DOM元素创建
  var originalCreateElement = document.createElement;
  document.createElement = function(tagName) {
    try {
      var element = originalCreateElement.call(this, tagName);
      if (element) {
        originalDefineProperty.call(Object, element, 'style', styleDescriptor);
      }
      return element;
    } catch (error) {
      console.warn('Error creating element:', error);
      return null;
    }
  };
})();

(function(){
  // 检测浏览器兼容性
  if (!window.Promise || !window.fetch) {
    alert('您的浏览器版本过低，请升级到最新版本以获得最佳体验。');
  }
  // 全局错误处理，拦截 style 报错
  window.addEventListener('error', function(event) {
    if (
      event && event.error && event.error.message &&
      event.error.message.indexOf("Cannot read properties of null (reading 'style')") !== -1
    ) {
      console.warn('拦截到 style 访问错误，已忽略');
      event.preventDefault();
      return false;
    }
    if (event && event.error) {
      console.error('全局错误:', event.error);
      event.preventDefault();
    }
  }, true);
  // 未处理的 Promise 拒绝
  window.addEventListener('unhandledrejection', function(event) {
    console.error('未处理的 Promise 拒绝:', event.reason);
    event.preventDefault();
  });
  // DOM 加载完成后再执行应用
  document.addEventListener('DOMContentLoaded', function() {
    console.log('DOM 加载完成');
  });
  window.addEventListener('load', function() {
    console.log('页面完全加载完成');
    setTimeout(function() {
      console.log('应用初始化延迟执行');
      if (document.getElementById('app')) {
        console.log('应用容器已就绪');
      }
    }, 200);
  });
  // DOM 元素访问保护
  var originalQuerySelector = document.querySelector;
  var originalGetElementById = document.getElementById;
  document.querySelector = function(selector) {
    var element = originalQuerySelector.call(this, selector);
    if (!element) {
      console.warn('Element not found:', selector);
      return null;
    }
    return element;
  };
  document.getElementById = function(id) {
    var element = originalGetElementById.call(this, id);
    if (!element) {
      console.warn('Element not found by ID:', id);
      return null;
    }
    return element;
  };
  // style 属性保护
  var originalGetAttribute = Element.prototype.getAttribute;
  var originalSetAttribute = Element.prototype.setAttribute;
  Element.prototype.getAttribute = function(name) {
    if (this == null) {
      console.warn('Attempting to get attribute on null/undefined element');
      return null;
    }
    return originalGetAttribute.call(this, name);
  };
  Element.prototype.setAttribute = function(name, value) {
    if (this == null) {
      console.warn('Attempting to set attribute on null/undefined element');
      return;
    }
    return originalSetAttribute.call(this, name, value);
  };
  Object.defineProperty(Element.prototype, 'style', {
    get: function() {
      if (this == null) {
        console.warn('Attempting to access style on null/undefined element');
        return {};
      }
      return this._style || (this._style = {});
    },
    set: function(value) {
      if (this == null) {
        console.warn('Attempting to set style on null/undefined element');
        return;
      }
      this._style = value;
    }
  });
  if (window.HTMLElement) {
    Object.defineProperty(HTMLElement.prototype, 'style', {
      get: function() {
        if (this == null) {
          console.warn('Attempting to access style on null/undefined HTMLElement');
          return {};
        }
        return this._style || (this._style = {});
      },
      set: function(value) {
        if (this == null) {
          console.warn('Attempting to set style on null/undefined HTMLElement');
          return;
        }
        this._style = value;
      }
    });
  }
  var originalCreateElement = document.createElement;
  document.createElement = function(tagName) {
    try {
      var element = originalCreateElement.call(this, tagName);
      Object.defineProperty(element, 'style', {
        get: function() {
          return this._style || (this._style = {});
        },
        set: function(value) {
          this._style = value;
        }
      });
      return element;
    } catch (error) {
      console.warn('Error creating element:', error);
      return null;
    }
  };
})();</script>
`;

// 替换现有的错误处理脚本
html = html.replace(
  /<script>[\s\S]*?<\/script>\s*<\/body>/,
  errorHandlerScript + '\n</body>'
);

// 写入修改后的 HTML 文件
fs.writeFileSync(htmlPath, html, 'utf8');

// 写入修改后的 public/index.html 文件（如果存在）
if (publicHtml) {
  fs.writeFileSync(publicHtmlPath, publicHtml, 'utf8');
  console.log('✅ 已成功修改 public/index.html 文件');
}

console.log('✅ 已成功修改 HTML 文件，移除了模块化依赖');
console.log('📁 文件位置: dist/index.html');
if (publicHtml) {
  console.log('📁 文件位置: dist/public/index.html');
}
console.log('🌐 现在可以直接通过 file:// 协议访问了！');